package org.yookiee.support.toolkits;

import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Strings;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.yookiee.support.core.EasyLocale;
import org.yookiee.support.core.I18NContext;
import org.yookiee.support.core.SysI18nAllocate;
import org.yookiee.support.core.datasource.I18nDatasource;
import org.yookiee.support.enums.Scope;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * FileName I18nToolkit
 * Package org.yookiee.support.toolkits
 * Description
 * author cpstory
 * create 2023-10-09 17:18
 * version V1.0
 */
@Slf4j
public class I18nToolkit {

    private static final String EMPTY = "";

    private static final String EXPRESSION_REGEX = "\\$\\{[^}]+\\}";

    private static final Pattern EXPRESSION_PATTERN = Pattern.compile(EXPRESSION_REGEX);

    private static I18nDatasource i18nDatasource;

    static {
        i18nDatasource = SpringContextToolkit.getApplicationContext().getBean(I18nDatasource.class);
    }

    /**
     * 传入的json应为如下格式：
     * {
     *     "zh_CN":"",
     *     "en": "",
     *     "ja_JP": "",
     *   }
     * @param targetJson
     * @return
     */
    public static String manualTrans(String targetJson){
        if(Strings.isNullOrEmpty(targetJson)){
            return EMPTY;
        }

        //手动对内容进行翻译
        EasyLocale locale = I18NContext.get();
        JSONObject editionDescJsonObject = null;
        try {
            editionDescJsonObject = JSONObject.parseObject(targetJson);
        } catch (Exception e) {
            log.error("手动处理国际化数据失败！数据模板异常！请联系相关人员处理！模版数据为：{}",targetJson);
            return EMPTY;
        }
        Object contextObj = editionDescJsonObject.get(locale.getLang());
        if(contextObj != null){
            return (String)contextObj;
        }
        return EMPTY;
    }


    /**
     * 手动翻译表达式
     * @param expression
     * @return
     */
    public static String manualTransExpression(String lang, String expression){
        if(Strings.isNullOrEmpty(expression)){
            return EMPTY;
        }
        List<String> params = I18nToolkit.findParams(expression);
        Map<String,SysI18nAllocate> allocateMap = i18nDatasource.getScopeData(Scope.JAVA.getScope());
        return I18nToolkit.dataProcess(lang, expression, allocateMap, params);
    }

    /**
     * 获取列表中数据类型
     * @param obj
     * @return
     */
    public static Class getArrayListClass(Object obj) {
        // 判断空，判断类型是否为列表，判断是否有数据（无数据无法获取类型）
        if (obj != null && ArrayList.class.equals(obj.getClass()) && ((List) obj).size() > 0) {
            return ((List) obj).get(0).getClass();
        }
        return null;
    }
    /**
     * 获取数据类型
     * @param obj
     * @return
     */
    public static Class getClass(Object obj) {
        // 判断空，判断类型是否为列表，判断是否有数据（无数据无法获取类型）
        if (obj != null && !ArrayList.class.equals(obj.getClass())) {
            return obj.getClass();
        }
        return null;
    }

    /**
     * 获取字符串中所有的变量参数
     * @param str 字符串/对象Json
     * @return
     */
    public static List<String> findParams(String str) {
        if (null == str){
            return null;
        }
        List<String> params = new ArrayList<>();

        if(Strings.isNullOrEmpty(str)){
            return null;
        }

        Matcher matcher = EXPRESSION_PATTERN.matcher(str);
        while (matcher.find()) {
            String expression = matcher.group();
            String param = expression.replaceAll("\\$\\{", "").replaceAll("\\}", "").trim();
            params.add(param);
        }
        return params;
    }

    /**
     * 数据处理
     * @param lang 语言环境
     * @param data 返回数据
     * @param languages 语言包
     * @param params 需要替换的参数列表
     * @return
     */
    public static String dataProcess(String lang, String data, Map<String,SysI18nAllocate> languages, List<String> params) {
        if (null == params){
            return data;
        }
        Map<String,String> waiteProcessMap = Maps.newHashMap();
        // 1.使用正则找出所有表达式
        Matcher matcher = EXPRESSION_PATTERN.matcher(data);
        while (matcher.find()) {
            String expression = matcher.group();
            // 如果已经翻译过了不需要再重复进行翻译
            if(waiteProcessMap.containsKey(expression) && !Strings.isNullOrEmpty(waiteProcessMap.get(expression))){
                continue;
            }
            // 2.解析出表达式,并翻译成对应的语言
            String param = expression.replaceAll("\\$\\{", "").replaceAll("\\}", "").trim();
            //处理未设置语言的情况
            lang = !Strings.isNullOrEmpty(lang) ? lang : DefaultConfigToolkit.defaultConfig.getLanguage();
            // 从缓存中获取对应的翻译
            if(languages.containsKey(param)){
                Map<String, String> langMeta = languages.get(param).getLangMeta();
                String translatedLang = langMeta.get(lang);
                waiteProcessMap.putIfAbsent(expression,translatedLang);
            }
        }
        // 3.使用正则替换表达式所在位置
        if(!waiteProcessMap.isEmpty()){
            for (String expression : waiteProcessMap.keySet()) {
                data = data.toString().replaceAll(Pattern.quote(expression),waiteProcessMap.get(expression));
            }
        }
        return data;
    }

}
